package com.company;

import com.company.exception.TaskConflictException;
import com.company.model.Task;
import com.company.service.TaskService;
import com.company.service.TaskServiceImpl;
import com.company.util.ReminderManager;
import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;

import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

/**
 * 个人日程管理系统 - 主交互入口
 * 整合功能：任务CRUD、今日/所有任务查看、完成标记、更新、统计、备份、提醒服务
 */
public class MainApp {
    // 依赖注入（实际项目可用Spring，此处简化为直接实例化）
    private static final TaskService taskService = new TaskServiceImpl();
    private static final Scanner scanner = new Scanner(System.in);
    // 时间格式化器（固定格式：yyyy-MM-dd HH:mm，处理非标准空格）
    private static final DateTimeFormatter TIME_FORMATTER = DateTimeFormat.forPattern("yyyy-MM-dd' 'HH:mm");

    public static void main(String[] args) {
        // 启动提醒服务（系统级异常捕获，避免启动失败导致程序退出）
        ReminderManager reminderManager = startReminderService();

        // 主交互循环（捕获所有系统级异常，保证程序可用性）
        while (true) {
            try {
                printMainMenu();
                System.out.print("请选择操作（输入数字1-8）：");
                String choice = scanner.nextLine().trim();
                handleUserChoice(choice, reminderManager);
            } catch (RuntimeException e) {
                // 统一处理系统错误（如数据库连接失败）
                System.err.println("\n⚠️  系统提示：" + e.getMessage());
                System.err.println("建议操作：1.检查数据库连接 2.确认文件路径权限 3.重启程序\n");
            }
        }
    }

    //启动提醒服务（单独封装，处理启动异常）
    private static ReminderManager startReminderService() {
        try {
            ReminderManager manager = new ReminderManager(taskService);
            manager.start();
            System.out.println("📢 提醒服务已启动，即将开始的任务会自动推送提醒。\n");
            return manager;
        } catch (RuntimeException e) {
            throw new RuntimeException("提醒服务启动失败：" + e.getMessage() + "（可能是线程资源不足）", e);
        }
    }

    //打印中文主菜单（包含所有功能）
    private static void printMainMenu() {
        System.out.println("=================== 个人日程管理系统 ===================");
        System.out.println("1. 添加新任务");
        System.out.println("2. 查看今日、本周或本月日程");
        System.out.println("3. 查看所有任务（按时间与id排序）");
        System.out.println("4. 查询任务详情");
        System.out.println("5. 更新已有任务");
        System.out.println("6. 查看本周、本月统计数据");
        System.out.println("7. 备份数据到CSV文件");
        System.out.println("8. 退出系统");
        System.out.println("=======================================================");
    }

    //处理用户菜单选择（分发功能）
    private static void handleUserChoice(String choice, ReminderManager reminderManager) {
        switch (choice) {
            case "1":
                addNewTask();
                break;
            case "2":
                viewTasks();
                break;
            case "3":
                viewAllTasks();
                break;
            case "4":
                queryTaskById();
                break;
            case "5":
                updateExistingTask();
                break;
            case "6":
                viewStats();
                break;
            case "7":
                backupData();
                break;
            case "8":
                exitSystem(reminderManager);
                break;
            default:
                System.err.println("❌ 输入错误：请仅输入 1-8 之间的整数（如1=添加任务、8=退出）\n");
        }
    }

    // ------------------------------ 功能方法 ------------------------------

    //1. 添加新任务（处理所有用户输入错误，含时间格式容错）

    private static void addNewTask() {
        try {
            // 1. 收集用户输入（trim()去空格，避免无效字符）
            String title = inputWithPrompt("请输入任务标题（必填，如：项目例会）：").trim();
            validateNotEmpty(title, "任务标题");

            String content = inputWithPrompt("请输入任务详情（可选，直接回车跳过）：").trim();
            String typeStr = inputWithPrompt("请输入任务类型（必填，仅支持：日常事务/deadline/会议）：").trim();
            validateNotEmpty(typeStr, "任务类型");

            String projectIdStr = inputWithPrompt("请输入所属项目ID（必填，如：1）：").trim();
            validateNotEmpty(projectIdStr, "项目ID");

            String priorityStr = inputWithPrompt("请输入任务优先级（必填，仅支持：低/中/高）：").trim();
            validateNotEmpty(priorityStr, "任务优先级");

            String startTimeStr = inputWithPrompt("请输入任务开始时间（必填，格式：yyyy-MM-dd HH:mm，例：2025-12-12 12:12）：").trim();
            validateNotEmpty(startTimeStr, "开始时间");

            String endTimeStr = inputWithPrompt("请输入任务结束时间（必填，格式同上）：").trim();
            validateNotEmpty(endTimeStr, "结束时间");

            // 2. 转换输入（时间解析前先净化空白字符）
            Task.TaskType type = Task.TaskType.valueOf(typeStr);
            int projectId = Integer.parseInt(projectIdStr);
            Task.Priority priority = Task.Priority.valueOf(priorityStr);
            DateTime startTime = parseTime(startTimeStr, "开始时间");
            DateTime endTime = parseTime(endTimeStr, "结束时间");

            // 3. 业务逻辑校验
            if (startTime.isAfter(endTime)) {
                throw new IllegalArgumentException("开始时间不能晚于结束时间（例：开始9:30，结束10:30）");
            }

            // 4. 调用服务添加任务
            Task newTask = Task.builder()
                    .title(title)
                    .content(content.isBlank() ? "无详情" : content)
                    .taskType(type)
                    .projectId(projectId)
                    .priority(priority)
                    .startTime(startTime)
                    .endTime(endTime)
                    .status(Task.TaskStatus.未开始)
                    .build();

            taskService.addTask(newTask);
            System.out.printf("\n✅ 任务添加成功！任务ID：%d，标题：%s，开始时间：%s%n%n",
                    newTask.getId(), newTask.getTitle(), formatTime(newTask.getStartTime()));

        } catch (NumberFormatException e) {
            System.err.println("\n❌ 输入错误：项目ID必须是整数（如：1、2，不能是文字或符号）");
            System.err.println("解决方案：重新输入纯数字ID（例：输入6表示关联项目6）\n");

        } catch (IllegalArgumentException e) {
            // 合并处理：时间解析错误、枚举不匹配、输入为空、时间逻辑错
            System.err.println("\n❌ 输入错误：" + e.getMessage());
            // 关键词判断：区分时间解析错误（含"格式错误"或"malformed"）
            if (e.getMessage().contains("格式错误") || e.getMessage().toLowerCase().contains("malformed")) {
                System.err.println("解决方案：");
                System.err.println("  1. 小时和分钟用英文冒号「:」（不要用横杠「-」或点「.」）");
                System.err.println("  2. 日期和时间之间用键盘空格（不要复制网页/文档的特殊空格）");
                System.err.println("  3. 正确示例：2025-12-12 12:12（年-月-日 时:分）");
            }
            // 关键词判断：区分枚举不匹配
            else if (e.getMessage().contains("No enum constant")) {
                if (e.getMessage().contains("TaskType")) {
                    System.err.println("解决方案：任务类型仅支持「日常事务、deadline、会议」（区分大小写，无空格）");
                } else if (e.getMessage().contains("Priority") || e.getMessage().contains("TaskStatus")) {
                    System.err.println("解决方案：优先级/状态仅支持中文选项（低/中/高 或 未开始/进行中/已完成/已取消、延迟）");
                }
            }
            System.err.println();

        } catch (TaskConflictException e) {
            // 任务时间冲突
            System.err.println("\n❌ 操作错误：新任务与已有任务时间冲突（同一时段已有其他任务）");
            System.err.println("解决方案：");
            System.err.println("  1. 调整新任务时间（例：将开始时间从12:12改为13:12）");
            System.err.println("  2. 删除冲突任务（先通过「3.查看所有任务」找到冲突任务ID）\n");
        }
    }

    //2. 查看今天、本周、本月的任务
    private static void viewTasks() {
        try {
            System.out.println("\n📅 任务查看选项");
            System.out.println("1. 查看今日任务");
            System.out.println("2. 查看本周任务");
            System.out.println("3. 查看本月任务");
            System.out.print("请选择查看方式（1-3）：");

            String choice = scanner.nextLine().trim();
            DateTime now = new DateTime();

            switch (choice) {
                case "1":
                    // 查看今日任务
                    System.out.printf("\n📅 今日日程列表（%s）%n", formatTime(now).split(" ")[0]);
                    List<Task> todayTasks = taskService.getTasksByDate(now);

                    if (todayTasks.isEmpty()) {
                        System.out.println("✅ 今日暂无日程安排，可通过「1.添加新任务」创建日程～\n");
                        return;
                    }

                    System.out.printf("共%d个任务：%n", todayTasks.size());
                    for (int i = 0; i < todayTasks.size(); i++) {
                        Task task = todayTasks.get(i);
                        String statusTag = task.getStatus() == Task.TaskStatus.已完成 ? "✅" : "⏳";
                        System.out.printf("%d. %s ID：%d | 标题：%s | 时间：%s | 优先级：%s | 状态：%s%n",
                                i + 1, statusTag, task.getId(), task.getTitle(),
                                formatTimeRange(task.getStartTime(), task.getEndTime()),
                                task.getPriority(), task.getStatus());
                    }
                    break;

                case "2":
                    // 查看本周任务
                    DateTime weekStart = now.withDayOfWeek(1).withTimeAtStartOfDay();
                    List<Task> weekTasks = taskService.getTasksByWeek(weekStart);

                    System.out.printf("\n📅 本周任务列表（%s至%s）%n",
                            formatTime(weekStart).split(" ")[0],
                            formatTime(weekStart.plusDays(6)).split(" ")[0]);

                    if (weekTasks.isEmpty()) {
                        System.out.println("✅ 本周暂无日程安排～\n");
                        return;
                    }

                    System.out.printf("共%d个任务：%n", weekTasks.size());
                    for (int i = 0; i < weekTasks.size(); i++) {
                        Task task = weekTasks.get(i);
                        String statusTag = task.getStatus() == Task.TaskStatus.已完成 ? "✅" : "⏳";
                        System.out.printf("%d. %s ID：%d | 标题：%s | 时间：%s | 优先级：%s | 状态：%s%n",
                                i + 1, statusTag, task.getId(), task.getTitle(),
                                formatTimeRange(task.getStartTime(), task.getEndTime()),
                                task.getPriority(), task.getStatus());
                    }
                    break;

                case "3":
                    // 查看本月任务
                    DateTime monthStart = now.withDayOfMonth(1).withTimeAtStartOfDay();
                    List<Task> monthTasks = taskService.getTasksByMonth(monthStart);

                    System.out.printf("\n📅 本月任务列表（%s）%n",
                            monthStart.toString("yyyy年MM月"));

                    if (monthTasks.isEmpty()) {
                        System.out.println("✅ 本月暂无日程安排～\n");
                        return;
                    }

                    System.out.printf("共%d个任务：%n", monthTasks.size());
                    for (int i = 0; i < monthTasks.size(); i++) {
                        Task task = monthTasks.get(i);
                        String statusTag = task.getStatus() == Task.TaskStatus.已完成 ? "✅" : "⏳";
                        System.out.printf("%d. %s ID：%d | 标题：%s | 时间：%s | 优先级：%s | 状态：%s%n",
                                i + 1, statusTag, task.getId(), task.getTitle(),
                                formatTimeRange(task.getStartTime(), task.getEndTime()),
                                task.getPriority(), task.getStatus());
                    }
                    break;

                default:
                    System.err.println("❌ 输入错误：请仅输入 1-3 之间的整数\n");
                    return;
            }

            System.out.println();

        } catch (RuntimeException e) {
            System.err.println("\n❌ 查询任务失败：" + e.getMessage() + "\n");
        }
    }

    //3. 查看所有任务（按时间与id排序）
    private static void viewAllTasks() {
        System.out.println("\n📋 所有任务列表（按开始时间与id排序）");
        Set<Task> allTasks = taskService.getAllTasksSortedByTime();

        if (allTasks.isEmpty()) {
            System.err.println("⚠️  系统中暂无任务，请先通过「1.添加新任务」创建第一个任务～\n");
            return;
        }

        System.out.printf("共%d个任务：%n", allTasks.size());
        int index = 1;
        for (Task task : allTasks) {
            String statusTag = task.getStatus() == Task.TaskStatus.已完成 ? "✅" : "⏳";
            System.out.printf("%d. %s ID：%d | 标题：%s | 时间：%s | 类型：%s | 状态：%s%n",
                    index++, statusTag, task.getId(), task.getTitle(),
                    formatTimeRange(task.getStartTime(), task.getEndTime()),
                    task.getTaskType(), task.getStatus());
        }
        System.out.println();
    }

    //4. 按ID查询任务详情
    private static void queryTaskById() {
        try {
            System.out.println("\n提示：先通过「3.查看所有任务」获取要查询的任务ID");
            String taskIdStr = inputWithPrompt("请输入要查询的任务ID：").trim();
            validateNotEmpty(taskIdStr, "任务ID");

            int taskId = Integer.parseInt(taskIdStr);

            // 根据任务ID查询任务详情
            Task task = taskService.getTaskById(taskId);
            if (task == null) {
                System.err.println("\n❌ 错误：未找到ID为 " + taskId + " 的任务，请检查任务ID是否正确\n");
                return;
            }

            // 显示任务详细信息
            System.out.println("\n🔍 任务详情查询结果：");
            System.out.println("=========================================");
            System.out.printf("任务ID：%d%n", task.getId());
            System.out.printf("任务标题：%s%n", task.getTitle());
            System.out.printf("任务详情：%s%n", task.getContent());
            System.out.printf("任务类型：%s%n", task.getTaskType());
            System.out.printf("所属项目ID：%d%n", task.getProjectId());
            System.out.printf("任务优先级：%s%n", task.getPriority());
            System.out.printf("开始时间：%s%n", formatTime(task.getStartTime()));
            System.out.printf("结束时间：%s%n", formatTime(task.getEndTime()));
            System.out.printf("任务状态：%s%n", task.getStatus());
            System.out.printf("创建时间：%s%n", formatTime(task.getCreatedTime()));
            System.out.printf("更新时间：%s%n", formatTime(task.getUpdatedTime()));
            if (task.getCompletedTime() != null) {
                System.out.printf("完成时间：%s%n", formatTime(task.getCompletedTime()));
            }
            System.out.println("=========================================\n");

        } catch (NumberFormatException e) {
            System.err.println("\n❌ 输入错误：任务ID必须是整数（如：1、2，不能是文字）");
            System.err.println("解决方案：先通过「3.查看所有任务」找到目标任务的数字ID\n");

        } catch (IllegalArgumentException e) {
            System.err.println("\n❌ 输入错误：" + e.getMessage() + "\n");

        } catch (RuntimeException e) {
            System.err.println("\n❌ 查询任务失败：" + e.getMessage() + "\n");
        }
    }


    //5. 更新已有任务（支持修改标题、内容、时间、状态）
    private static void updateExistingTask() {
        try {
            // 1. 获取任务ID并校验
            System.out.println("\n提示：先通过「3.查看所有任务」获取要更新的任务ID");
            String taskIdStr = inputWithPrompt("请输入要更新的任务ID：").trim();
            validateNotEmpty(taskIdStr, "任务ID");
            int taskId = Integer.parseInt(taskIdStr);

            // 2. 从数据库加载完整的旧任务数据
            Task oldTask = taskService.getTaskById(taskId);
            if (oldTask == null) {
                System.err.println("\n❌ 错误：未找到ID为 " + taskId + " 的任务，请检查任务ID是否正确\n");
                return;
            }

            // 3. 收集用户输入（支持"直接回车不修改"）
            String newTitle = inputWithPrompt("请输入新标题（原标题：" + oldTask.getTitle() + "，回车不修改）：").trim();
            String newContent = inputWithPrompt("请输入新详情（原详情：" + oldTask.getContent() + "，回车不修改）：").trim();
            String newStatusStr = inputWithPrompt("请输入新状态（仅支持：未开始、进行中、已完成、已取消、延迟，回车不修改）：").trim();
            String newStartTimeStr = inputWithPrompt("请输入新开始时间（格式：年-月-日 时:分，回车不修改）：").trim();
            String newEndTimeStr = inputWithPrompt("请输入新结束时间（格式同上，回车不修改）：").trim();

            // 4. 构建更新后的任务（保留旧值，仅覆盖用户输入的新值）
            Task updatedTask = Task.builder()
                    .id(taskId) // 必须保留原ID
                    .title(newTitle.isBlank() ? oldTask.getTitle() : newTitle)
                    .content(newContent.isBlank() ? oldTask.getContent() : newContent)
                    .taskType(oldTask.getTaskType()) // 从数据库加载的完整数据
                    .projectId(oldTask.getProjectId()) // 从数据库加载的完整数据
                    .priority(oldTask.getPriority()) // 从数据库加载的完整数据
                    .startTime(newStartTimeStr.isBlank() ? oldTask.getStartTime() : parseTime(newStartTimeStr, "新开始时间"))
                    .endTime(newEndTimeStr.isBlank() ? oldTask.getEndTime() : parseTime(newEndTimeStr, "新结束时间"))
                    .status(newStatusStr.isBlank() ? oldTask.getStatus() : Task.TaskStatus.valueOf(newStatusStr))
                    .build();

            // 5. 时间逻辑校验（若修改了时间）
            if (!newStartTimeStr.isBlank() && !newEndTimeStr.isBlank()) {
                if (updatedTask.getStartTime().isAfter(updatedTask.getEndTime())) {
                    throw new IllegalArgumentException("新开始时间不能晚于新结束时间");
                }
            }

            // 6. 调用服务更新任务
            taskService.updateTask(updatedTask);
            System.out.printf("\n✅ 任务更新成功！ID：%d，最新标题：%s%n%n",
                    updatedTask.getId(), updatedTask.getTitle());

        } catch (NumberFormatException e) {
            System.err.println("\n❌ 输入错误：任务ID必须是整数（如：1、2）\n");

        } catch (IllegalArgumentException e) {
            // 合并处理：时间解析错误、枚举不匹配、输入为空
            System.err.println("\n❌ 输入错误：" + e.getMessage());
            if (e.getMessage().contains("格式错误") || e.getMessage().toLowerCase().contains("malformed")) {
                System.err.println("解决方案：参考正确格式「2025-12-12 12:12」，注意用冒号分隔小时和分钟\n");
            } else if (e.getMessage().contains("No enum constant") && e.getMessage().contains("TaskStatus")) {
                System.err.println("解决方案：状态仅支持「未开始、进行中、已完成、已取消、延迟」\n");
            } else {
                System.err.println();
            }

        } catch (RuntimeException e) {
            System.err.println("\n❌ 更新任务失败：" + e.getMessage() + "\n");
        }
    }

    //6. 查看统计数据（支持本周和本月）
private static void viewStats() {
    try {
        System.out.println("\n📊 统计数据查看选项");
        System.out.println("1. 查看本周统计数据");
        System.out.println("2. 查看本月统计数据");
        System.out.print("请选择查看方式（1-2）：");

        String choice = scanner.nextLine().trim();
        DateTime now = new DateTime();
        int year = now.getYear();
        int week = now.getWeekOfWeekyear(); // ISO周数（1-53）
        int month = now.getMonthOfYear();

        switch (choice) {
            case "1":
                // 查看本周统计数据

                System.out.printf("\n📊 本周统计数据（%d年 第%d周）%n", year, week);
                Map<String, Integer> weeklyStats = taskService.getWeeklyStats(year, week);

                // 解析统计结果
                int total = weeklyStats.getOrDefault("total", 0);
                int completed = weeklyStats.getOrDefault("completed", 0);
                int overdue = weeklyStats.getOrDefault("overdue", 0);
                double overdueRate = total == 0 ? 0 : Math.round((double) overdue / total * 1000) / 10.0; // 保留1位小数

                // 中文友好输出
                System.out.println("1. 本周总任务数：" + total + " 个");
                System.out.println("2. 已完成任务数：" + completed + " 个");
                System.out.println("3. 延迟未完成任务数：" + overdue + " 个");
                System.out.println("4. 延迟率：" + overdueRate + "%");

//                // 场景化建议
//                if (total == 0) {
//                    System.out.println("⚠️  提示：本周暂无任务，可通过「1.添加新任务」规划本周日程");
//                } else if (completionRate < 50) {
//                    System.out.println("💡 建议：本周任务完成率较低，可优先处理「deadline」类型任务");
//                } else if (completionRate < 80) {
//                    System.out.println("💡 建议：本周完成率良好，可提前规划下周任务");
//                } else {
//                    System.out.println("🎉 恭喜：本周任务完成率优秀，继续保持！");
//                }
                 break;

            case "2":
                // 查看本月统计数据
                Map<String, Integer> monthlyStats = taskService.getMonthlyStats(year, month);

                System.out.printf("\n📊 本月统计数据（%d年 %d月）%n", year, month);

                // 解析统计结果
                int monthlyTotal = monthlyStats.getOrDefault("total", 0);
                int monthlyCompleted = monthlyStats.getOrDefault("completed", 0);
                int monthlyOverdue = monthlyStats.getOrDefault("overdue", 0);
                double monthlyOverdueRate = monthlyTotal == 0 ? 0 : Math.round((double) monthlyOverdue / monthlyTotal * 1000) / 10.0; // 保留1位小数

                // 中文友好输出
                System.out.println("1. 本月总任务数：" + monthlyTotal + " 个");
                System.out.println("2. 已完成任务数：" + monthlyCompleted + " 个");
                System.out.println("3. 延迟未完成任务数：" + monthlyOverdue + " 个");
                System.out.println("4. 延迟率：" + monthlyOverdueRate + "%");

//                // 场景化建议
//                if (monthlyTotal == 0) {
//                    System.out.println("⚠️  提示：本月暂无任务，可通过「1.添加新任务」规划本月日程");
//                } else if (monthlyCompletionRate < 50) {
//                    System.out.println("💡 建议：本月任务完成率较低，可优先处理重要任务");
//                } else if (monthlyCompletionRate < 80) {
//                    System.out.println("💡 建议：本月完成率良好，可继续保持");
//                } else {
//                    System.out.println("🎉 恭喜：本月任务完成率优秀，继续保持！");
//                }
                break;

            default:
                System.err.println("❌ 输入错误：请仅输入 1-2 之间的整数\n");
                return;
        }

        System.out.println();

    } catch (RuntimeException e) {
        System.err.println("\n❌ 查询统计数据失败：" + e.getMessage() + "\n");
    }
}


    //7. 备份数据到CSV文件
    private static void backupData() {
        try {
            String filePath = inputWithPrompt("请输入备份文件保存路径（例：D:\\日程备份20251212.csv）：").trim();
            validateNotEmpty(filePath, "备份路径");

            // 路径合法性校验（简单校验：包含盘符和.csv后缀）
            if (!filePath.contains(":") || !filePath.endsWith(".csv")) {
                throw new IllegalArgumentException("路径格式不合法（需包含盘符且以.csv结尾）");
            }

            taskService.backupData(filePath);
            System.out.printf("\n✅ 数据备份成功！文件位置：%s%n%n", filePath);

        } catch (IllegalArgumentException e) {
            System.err.println("\n❌ 输入错误：" + e.getMessage());
            System.err.println("正确示例：D:\\我的日程备份.csv、E:\\2025年12月备份.csv\n");

        } catch (RuntimeException e) {
            throw new RuntimeException("备份失败：" + e.getMessage() + "（建议：1.检查路径是否存在 2.关闭占用文件的程序）", e);
        }
    }

    //8. 退出系统（资源清理）
    private static void exitSystem(ReminderManager reminderManager) {
        System.out.println("正在关闭系统...");
        reminderManager.stop(); // 停止提醒服务
        scanner.close(); // 关闭输入流
        System.out.println("系统已安全退出，感谢使用！");
        System.exit(0);
    }

    // ------------------------------ 工具方法 ------------------------------

    //通用输入提示方法（简化重复代码）
    private static String inputWithPrompt(String prompt) {
        System.out.print(prompt);
        return scanner.nextLine();
    }

    //校验输入不为空（为空则抛异常）
    private static void validateNotEmpty(String input, String fieldName) {
        if (input.isBlank()) {
            throw new IllegalArgumentException(fieldName + "不能为空（请补全后重试）");
        }
    }

    //时间解析（处理非标准空格，统一格式）

    private static DateTime parseTime(String timeStr, String timeType) {
        try {
            // 净化空白字符：将所有空白（包括非标准空格）替换为标准空格
            String cleanTimeStr = timeStr.replaceAll("\\s+", " ");
            return TIME_FORMATTER.parseDateTime(cleanTimeStr);
        } catch (IllegalArgumentException e) {
            // 改用通用IllegalArgumentException，附加时间类型信息
            throw new IllegalArgumentException(timeType + "格式错误：" + e.getMessage());
        }
    }

    //时间格式化（统一输出格式）
    private static String formatTime(DateTime dateTime) {
        return TIME_FORMATTER.print(dateTime);
    }

    //时间范围格式化（开始时间 - 结束时间）
    private static String formatTimeRange(DateTime startTime, DateTime endTime) {
        return formatTime(startTime) + " - " + formatTime(endTime);
    }
}